//这段代码是一个 Spring Boot 的 REST 控制器，主要用于一个假设应用程序的管理员仪表板。该控制器提供了几个端点，用于获取与考试、任务和用户活动相关的各种统计信息和数据。
package com.mindskip.xzs.controller.admin;

import com.mindskip.xzs.base.BaseApiController;
import com.mindskip.xzs.base.RestResponse;
import com.mindskip.xzs.domain.ExamPaper;
import com.mindskip.xzs.domain.TResult;
import com.mindskip.xzs.domain.TaskExam;
import com.mindskip.xzs.domain.TaskExamResult;
import com.mindskip.xzs.service.*;
import com.mindskip.xzs.utility.DateTimeUtil;
import com.mindskip.xzs.viewmodel.admin.dashboard.IndexVM;
import com.mindskip.xzs.viewmodel.admin.task.TResultResponseVM;
import com.mindskip.xzs.viewmodel.admin.task.TaskResultInfoResponseVm;
import com.mindskip.xzs.viewmodel.admin.task.TaskResultResponseVM;
import com.mindskip.xzs.viewmodel.admin.task.TestResultInfoResponseVM;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import java.util.LinkedList;
import java.util.List;

@RestController("AdminDashboardController")
@RequestMapping(value = "/api/admin/dashboard")
public class DashboardController extends BaseApiController {

    private final ExamPaperService examPaperService;//用于操作考试试卷的服务。
    private final QuestionService questionService;//用于操作问题/题目的服务。
    private final ExamPaperAnswerService examPaperAnswerService;//用于操作考试试卷答案的服务。



    @Autowired//使用 @Autowired 注解的构造函数，注入上述服务实例。
    public DashboardController(ExamPaperService examPaperService, QuestionService questionService, ExamPaperAnswerService examPaperAnswerService) {
        this.examPaperService = examPaperService;
        this.questionService = questionService;
        this.examPaperAnswerService = examPaperAnswerService;

    }

    @Resource//通过 @Resource 注解注入的服务，用于处理任务和批处理相关的操作。
    private TaskServer taskServer;
    @Resource
    private TaskResultServer taskResultServer;
    @Resource
    private BatchTaskServer batchTaskServer;
    @Resource
    private  BatchUserServer batchUserServer;
    @Resource
    private TResultServer tResultServer;

    @RequestMapping(value = "/index", method = RequestMethod.POST)
    //Index 方法。路径：/index,请求方法：POST,功能：获取仪表板的主要统计信息。,返回：包含考试试卷数、问题数、已完成的考试试卷数、已完成的问题数、每月用户活动和每月完成问题数的 IndexVM 对象。
    public RestResponse<IndexVM> Index() {
        IndexVM vm = new IndexVM();

        Integer examPaperCount = examPaperService.selectAllCount();
        Integer questionCount = questionService.selectAllCount();
        Integer doExamPaperCount = examPaperAnswerService.selectAllCount();

        vm.setExamPaperCount(examPaperCount);
        vm.setQuestionCount(questionCount);
        vm.setDoExamPaperCount(doExamPaperCount);



        vm.setMothDayText(DateTimeUtil.MothDay());
        return RestResponse.ok(vm);
    }
    @RequestMapping(value = "/taskResultNewest/{taskId}",method = RequestMethod.GET)
    //getTaskResultNews 方法.路径：/taskResultNewest/{taskId},请求方法：GET,功能：获取最新的任务结果。,参数：taskId（任务ID）,返回：最新的任务结果列表。
    public RestResponse getTaskResultNews(@PathVariable Integer taskId){
        List<TaskExamResult> taskExamResults=new LinkedList<>();
        if(taskId.equals(0)){
            List<TaskExam> taskExams=taskServer.list();
            for(int i=taskExams.size()-1;i>=0;i--) {
                if (taskResultServer.getTaskResultByTaskId(taskExams.get(i).getId()).size() > 0) {
                    taskExamResults = taskResultServer.getTaskResultByTaskId(taskExams.get(i).getId());
                    break;
                }
            }
        }else {
            taskExamResults=taskResultServer.getTaskResultByTaskId(taskId);
        }
        return RestResponse.ok(formatTaskResult(taskExamResults));
    }

    @RequestMapping(value = "/taskResultInfo/{taskId}", method = RequestMethod.GET)
    //功能：获取指定任务的详细结果信息,任务结果的详细信息，包括任务数、批次数、任务计数、试卷计数、任务ID和任务名称
    public  RestResponse getTaskResultInfo(@PathVariable Integer taskId){
        TaskResultInfoResponseVm taskResultInfoResponseVm=new TaskResultInfoResponseVm();
            if(taskId.equals(0)){
                List<TaskExam> taskExams=taskServer.list();
                for(int i=taskExams.size()-1;i>=0;i--) {
                    if (taskResultServer.getTaskResultByTaskId(taskExams.get(i).getId()).size() > 0) {
                        taskResultInfoResponseVm.setTaskNum(taskResultServer.getTaskResultByTaskId(taskExams.get(i).getId()).size());
                        taskResultInfoResponseVm.setBatchNum(batchUserServer.getBatchUserByBatchId(batchTaskServer.getBathIdByTaskId(taskExams.get(i).getId()).get(0)).size()); //这里一个测试只能绑定一个批次
                        taskResultInfoResponseVm.setTaskCount(taskServer.getTaskExamByCreateUserId(taskExams.get(i).getCreateUser()).size());
                        taskResultInfoResponseVm.setExamPaperCount(examPaperService.getExamPaperByCreateUserId(taskExams.get(i).getCreateUser()).size());
                        taskResultInfoResponseVm.setTaskId(taskExams.get(i).getId());
                        taskResultInfoResponseVm.setTaskName(taskExams.get(i).getTitle());
                        break;
                    }
                }
            }else {
                TaskExam taskExam = taskServer.getById(taskId);
                taskResultInfoResponseVm.setTaskNum(taskResultServer.getTaskResultByTaskId(taskId).size());
                taskResultInfoResponseVm.setBatchNum(batchUserServer.getBatchUserByBatchId(batchTaskServer.getBathIdByTaskId(taskId).get(0)).size()); //这里一个测试只能绑定一个批次
                taskResultInfoResponseVm.setTaskCount(taskServer.getTaskExamByCreateUserId(taskExam.getCreateUser()).size());
                taskResultInfoResponseVm.setExamPaperCount(examPaperService.getExamPaperByCreateUserId(taskExam.getCreateUser()).size());
                taskResultInfoResponseVm.setTaskName(taskExam.getTitle());
            }
            return RestResponse.ok(taskResultInfoResponseVm);
    }

    @RequestMapping(value = "/batchTaskList",method = RequestMethod.GET)
    //功能：获取批处理任务列表。
    //返回：包含有任务结果的任务列表。
    public  RestResponse getBatchTaskList(){
        List<TaskExam> taskExams=taskServer.list();
        List<TaskExam> taskExamList=new LinkedList<>();
        for (TaskExam taskExam:taskExams){
            if(taskResultServer.getTaskResultByTaskId(taskExam.getId()).size()>0){
                    taskExamList.add(taskExam);
            }
        }
        return  RestResponse.ok(taskExamList);
    }

    @RequestMapping(value = "/testResultList/{taskId}",method = RequestMethod.GET)
    public  RestResponse testResultList(@PathVariable Integer taskId){
        //根据任务ID获取任务结果
        List<TaskExamResult> taskExamResults=taskResultServer.getTaskResultByTaskId(taskId);
        //存储结果ID的列表
        List<Integer> resultIds=new LinkedList<>();
        //存储结果视图模型列表
        List<TResultResponseVM> tResultResponseVMS=new LinkedList<>();
        //如果有结果
        if(taskExamResults.size()>0) {
            //遍历任务结果，提取结果ID
            for (TaskExamResult taskExamResult : taskExamResults) {
                resultIds.add(taskExamResult.getResultId());
            }
            //用于去重的ID列表
            List<Integer> ids = new LinkedList<>();
            // 遍历结果ID
            for (Integer resultId : resultIds) {
                // 如果ID未在ids列表中
                if (!ids.contains(resultId)) {
                    // 创建结果视图模型并设置ID
                    TResultResponseVM tResultResponseVM = new TResultResponseVM();
                    tResultResponseVM.setId(resultId);
                    // 获取结果对象并设置名称
                    TResult tResult = tResultServer.getById(resultId);
                    tResultResponseVM.setName(tResult.getName() + '(' + tResult.getInfo() + ')');
                    // 将结果视图模型添加到列表
                    tResultResponseVMS.add(tResultResponseVM);
                    // 将ID添加到ids列表中
                    ids.add(resultId);
                }
            }
        }
        return  RestResponse.ok(tResultResponseVMS);
    }

    /**
    * @Description: 格式化统计测试返回数据
    * @Param: [list]
    * @return: java.util.List<com.mindskip.xzs.viewmodel.admin.task.TaskResultResponseVM>
    */
    public TestResultInfoResponseVM formatTaskResult(List<TaskExamResult> list){
        // 创建返回对象
        TestResultInfoResponseVM testResultInfoResponseVM=new TestResultInfoResponseVM();
        // 初始化各类型结果的计数数组
        Integer[] testResultType={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
        // 每种类型的详细描述
        String [] testResultTypeName = {"ESTJ(执行的)实际、现实主义","ESTP(企业家)灵活、忍耐力强","ESFJ(领事)热心肠、有责任心、合作","ESFP(演艺人员)外向、友好、接受力强。热爱生活、人类和物质上的享受","ENTJ(指挥官)坦诚、果断，有天生的领导能力","ENTP(辩手)反应快、容智，有激励别人的能力，警觉性强、直言不违","ENFJ(主角)执惜、为他人着想、易感应、有责任心。非常许重他人的感错、需求和动规","ENFP(活动家)热情洋溢、富有想象力。认为人生有很多的可能性","INFP(调解人)理想主义，对于自己的价值观和自己觉得重要的人非常忠诚","INTJ(建筑师)在实现自己的想法和达成自己的目标时有创新的想法和非凡的动力","INTP(逻辑学家)对于自己感兴趣的任何事物都寻求找到合理的解","INFJ(提倡)寻求思想、关系、物质等之间的意义和联系","ISTJ(物流师)安静、严肃，通过全面性和可靠性获得成功","ISTP(演奏家)灵活、忍耐力强，是个安静的观察者直到有问题发生，就会马上行动，找到实用的解决方法","ISFJ(辩护人)安静、友好、有责任感和良知。坚定地致力于完成他们的义务","ISFP(冒险家)安静、友好、镜感、和善。享受当前"};
        // 每种类型的简短描述
        String [] testResultFixName={"ESTJ(执行的)","ESTP(企业家)","ESFJ(领事)","ESFP(演艺人员)","ENTJ(指挥官)","ENTP(辩手)","ENFJ(主角)","ENFP(活动家)","INFP(调解人)","INTJ(建筑师)","INTP(逻辑学家)","INFJ(提倡)","ISTJ(物流师)","ISTP(演奏家)","ISFJ(辩护人)","ISFP(冒险家)"};
        // 存储最终结果的视图模型列表
        List<TaskResultResponseVM> taskResultResponseVMS=new LinkedList<>();
        // 遍历任务结果列表，根据结果ID进行计数
        for(TaskExamResult taskExamResult:list){
                switch (taskExamResult.getResultId()){
                    case 1:
                        testResultType[0]++;
                        break;
                    case 2:
                        testResultType[1]++;
                        break;
                    case 3:
                        testResultType[2]++;
                        break;
                    case 4:
                        testResultType[3]++;
                        break;
                    case 5:
                        testResultType[4]++;
                        break;
                    case 6:
                        testResultType[5]++;
                        break;
                    case 7:
                        testResultType[6]++;
                        break;
                    case 8:
                        testResultType[7]++;
                        break;
                    case 9:
                        testResultType[8]++;
                        break;
                    case 10:
                        testResultType[9]++;
                        break;
                    case 11:
                        testResultType[10]++;
                        break;
                    case 12:
                        testResultType[11]++;
                        break;

                    case 13:
                        testResultType[12]++;
                        break;

                    case 14:
                        testResultType[13]++;
                        break;
                    case 15:
                        testResultType[14]++;
                        break;
                    case 16:
                        testResultType[15]++;
                        break;

                }
        }
        // 遍历计数数组，生成结果视图模型并添加到列表
        for(int y=0;y<testResultType.length;y++){
            if(testResultType[y]>0) {
                TaskResultResponseVM taskResultResponseVM = new TaskResultResponseVM();
                taskResultResponseVM.setName(testResultFixName[y]);
                taskResultResponseVM.setValue(testResultType[y]);
                taskResultResponseVMS.add(taskResultResponseVM);
            }
        }
        // 存储详细描述的列表
        List<String> infoDatas= new LinkedList<>();
        for(int z=0;z<testResultFixName.length;z++){
            infoDatas.add(testResultTypeName[z]);
        }
        // 设置返回对象的属性
        testResultInfoResponseVM.setInfoDatas(infoDatas);
        testResultInfoResponseVM.setDatas(taskResultResponseVMS);
        // 返回格式化后的结果
        return testResultInfoResponseVM;
    }
}
